package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.enums.EhsHazardIndentificationResultTypeEnum;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.DateUtil;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.hazard.EhsHazardInfoDto;
import qc.module.ehs.dto.hazardidentity.*;
import qc.module.ehs.dto.templatehazard.TplHazardCategoryDto;
import qc.module.ehs.dto.templatehazard.TplHazardItemDto;
import qc.module.ehs.dto.templatehazard.TplHazardProjectDto;
import qc.module.ehs.dto.troublecorrect.EhsTroubleCorrectInfoDto;
import qc.module.ehs.dto.unit.EhsUnitSimpleDto;
import qc.module.ehs.entity.*;
import qc.module.ehs.mapper.EhsHazardIdentifyMapper;
import qc.module.ehs.mapper.EhsUnitInfoMapper;
import qc.module.ehs.repository.*;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 危险源辨识记录信息Service
 * @author QuCheng Tech
 * @create 2024/11/5
 */
@Service
public class EhsHazardIdentifyService {

    @Autowired
    private EhsHazardIdentifyRepository repository;

    @Autowired
    private EhsUnitInfoRepository unitInfoRepository;

    @Autowired
    private EhsHazardInfoService hazardInfoService;

    @Autowired
    private EhsTplUnitcategoryService unitcategoryService;

    @Autowired
    private EhsTplHazarditemService hazarditemService;

    @Autowired
    private EhsTplHazardprojectService hazardprojectService;

    @Autowired
    private EhsTplHazardcategoryService hazardcategoryService;

    @Autowired
    private EhsUnitInfoService unitInfoService;

    @Autowired
    private EhsTroubleCorrectService troubleCorrectService;

    @Autowired
    private EhsTaskExecService taskExecService;

    @Autowired
    private EhsTaskItemRepository taskItemRepository;

    @Autowired
    private EhsTaskInfoRepository taskInfoRepository;

    @Autowired
    private EhsTaskGroupRepository taskGroupRepository;

    /**
     * 查询危险源辨识记录
     * @param condition 查询条件
     * @return HazardIdentifyQueryResultDto
     * @author QuCheng Tech
     * @description 1.用于查询指定时间段内的危险源辨识记录；
     * 2.查询当前用户有权限的单元指定时间段内的辨识记录；
     * 3.返回结果按单元进行显示，每个单元显示所有辨识记录（可能会有多个时间的辨识记录），单元有子级单元时按单元层级关系显示；
     * @since 2024/11/5
     */
    public HazardIdentifyQueryResultDto query(HazardIdentifyQueryConditionDto condition) throws QCPromptException {
        //1.查询条件有效性验证
        if (condition == null)
            throw new QCPromptException("查询条件不能为空");
        if (StringUtils.isBlank(condition.getOrgcode()))
            throw new QCPromptException("组织代码不能为空");
        if (StringUtils.isBlank(condition.getBegintm()))
            throw new QCPromptException("查询起始时间不能为空");
        if (StringUtils.isBlank(condition.getEndtm()))
            throw new QCPromptException("查询截止时间不能为空");
        //查询时间处理
        Date beginDate = null;
        Date endDate = null;
        if (StringUtils.isNotBlank(condition.getBegintm())) {
            try {
                beginDate = DateUtil.parseDate(condition.getBegintm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询条件中的开始日期转换错误");
            }
        }
        if (StringUtils.isNotBlank(condition.getEndtm())) {
            try {
                endDate = DateUtil.parseDate(condition.getEndtm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询条件中的截止日期转换错误");
            }
        }

        //2.查询指定条件的单元信息，如果查询指定单元（该单元作为一级单元，返回子级）,否则查询指定组织所有
        List<EhsUnitInfo> units = new ArrayList<>();
        LambdaQueryWrapper<EhsUnitInfo> unitWrapper = new LambdaQueryWrapper<>();
        unitWrapper.eq(EhsUnitInfo::getOrgcode, condition.getOrgcode());
        //查询指定单元
        if (StringUtils.isNotBlank(condition.getUnitid())) {
            unitWrapper.eq(EhsUnitInfo::getUnitid, condition.getUnitid());
            EhsUnitInfo unitInfo = unitInfoRepository.selectOne(unitWrapper);
            units.add(unitInfo);
            //查询单元的子级单元
            LambdaQueryWrapper<EhsUnitInfo> subUnitWrapper = new LambdaQueryWrapper<>();
            subUnitWrapper.ne(EhsUnitInfo::getUnitid, unitInfo.getUnitid())
                    .likeRight(EhsUnitInfo::getLevelcode, unitInfo.getLevelcode())//根据单元的层级编码开头去查询子级
                    .orderByAsc(EhsUnitInfo::getOdr, EhsUnitInfo::getUnitname);
            List<EhsUnitInfo> subUniInfos = unitInfoRepository.selectList(subUnitWrapper);
            if (CollectionUtils.isNotEmpty(subUniInfos)) units.addAll(subUniInfos);
        } else {
            unitWrapper.orderByAsc(EhsUnitInfo::getOdr, EhsUnitInfo::getUnitname);
            units = unitInfoRepository.selectList(unitWrapper);
        }
        if (CollectionUtils.isEmpty(units))
            return null;

        List<EhsUnitSimpleDto> unitSimpleDtos = EhsUnitInfoMapper.MAPPER.toDtoSimpleList(units);

        //3.设置返回结果项信息
        List<HazardIdentifyQueryResultItemDto> items = new ArrayList<>();
        //获取根节点集合（如果查询指定单元，将指定单元作为根层级单元，否则parentid为空的作为根层级单元）
        List<EhsUnitSimpleDto> rootUnits = new ArrayList<>();
        if (StringUtils.isNotBlank(condition.getUnitid())) {
            rootUnits = unitSimpleDtos.stream().
                    filter(p -> p.getUnitid().equals(condition.getUnitid())).collect(Collectors.toList());
        } else {
            rootUnits = unitSimpleDtos.stream().
                    filter(p -> StringUtils.isEmpty(p.getParentid())).collect(Collectors.toList());
        }
        Date finalBeginDate = beginDate;
        Date finalEndDate = endDate;
        rootUnits.stream().forEach(unit -> {
            HazardIdentifyQueryResultItemDto item = new HazardIdentifyQueryResultItemDto();
            item.setUnit(unit);
            List<HazardIdentifyInfoDto> identifys = new ArrayList<>();
            //获取指定单元指定周期的辨识记录
            LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(EhsHazardIdentify::getUnitid, unit.getUnitid())
                    .and(q -> {
                        q.ge(EhsHazardIdentify::getTm, finalBeginDate).le(EhsHazardIdentify::getTm, finalEndDate);
                    })
                    .orderByAsc(EhsHazardIdentify::getCategoryname, EhsHazardIdentify::getProjectname, EhsHazardIdentify::getItemname)
                    .orderByDesc(EhsHazardIdentify::getTm);
            List<EhsHazardIdentify> identifies = repository.selectList(wrapper);
            if (CollectionUtils.isNotEmpty(identifies)) {
                for (EhsHazardIdentify en : identifies) {
                    identifys.add(EhsHazardIdentifyMapper.MAPPER.entityToDto(en));
                }
            }
            item.setIdentifys(identifys);
            //设置子级单元
            List<HazardIdentifyQueryResultItemDto> childs = new ArrayList<>();
            getSubUnits(unitSimpleDtos, item, childs, finalBeginDate, finalEndDate);
            item.setChilds(childs);
            items.add(item);
        });

        //设置结果并返回
        HazardIdentifyQueryResultDto result = new HazardIdentifyQueryResultDto();
        result.setItems(items);
        return result;
    }

    /**
     * 递归获取指定单元的所有子级单元集合
     * @param unitSimpleDtos 所有单元集合
     * @param parentItem     父单元项信息
     * @param childs         父单元的子单元项集合
     * @author QuCheng Tech
     * @since 2024/11/5
     */
    public void getSubUnits(List<EhsUnitSimpleDto> unitSimpleDtos, HazardIdentifyQueryResultItemDto parentItem,
                            List<HazardIdentifyQueryResultItemDto> childs, Date finalBeginDate, Date finalEndDate) {

        //获取当前单元的子级单元
        List<EhsUnitSimpleDto> subUnits = unitSimpleDtos.stream().filter(unit ->
                unit.getParentid() != null && unit.getParentid().equals(parentItem.getUnit().getUnitid())).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(subUnits)) {
            subUnits.stream().forEach(subUnit -> {
                HazardIdentifyQueryResultItemDto subItem = new HazardIdentifyQueryResultItemDto();
                subItem.setUnit(subUnit);
                List<HazardIdentifyInfoDto> identifys = new ArrayList<>();
                //获取指定单元指定周期的辨识记录
                LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
                wrapper.eq(EhsHazardIdentify::getUnitid, subUnit.getUnitid())
                        .and(q -> {
                            q.ge(EhsHazardIdentify::getTm, finalBeginDate).le(EhsHazardIdentify::getTm, finalEndDate);
                        })
                        .orderByAsc(EhsHazardIdentify::getCategoryname, EhsHazardIdentify::getProjectname, EhsHazardIdentify::getItemname)
                        .orderByDesc(EhsHazardIdentify::getTm);
                List<EhsHazardIdentify> identifies = repository.selectList(wrapper);
                if (CollectionUtils.isNotEmpty(identifies)) {
                    for (EhsHazardIdentify en : identifies) {
                        identifys.add(EhsHazardIdentifyMapper.MAPPER.entityToDto(en));
                    }
                }
                subItem.setIdentifys(identifys);
                //设置子级单元
                List<HazardIdentifyQueryResultItemDto> subChilds = new ArrayList<>();
                getSubUnits(unitSimpleDtos, subItem, subChilds, finalBeginDate, finalEndDate);
                subItem.setChilds(subChilds);

                childs.add(subItem);
                parentItem.setChilds(childs);
            });
        }
    }

    /**
     * 查询指定单元的辨识记录，按辨识时间降序返回
     *
     * @param unitid    单元ID
     * @param beginTime 起始时间
     * @param endTime   截止时间
     * @return java.util.List<qc.module.ehs.dto.hazardidentity.HazardIdentifyInfoDto>
     * @author QuCheng Tech
     * @since 2025/6/11
     */
    public List<HazardIdentifyInfoDto> queryByUnit(String unitid, Date beginTime, Date endTime) {
        List<EhsHazardIdentify> identifies = queryUnitHazardIdentifyEntities(unitid, beginTime, endTime);
        if (CollectionUtils.isNotEmpty(identifies)) {
            List<HazardIdentifyInfoDto> result = new ArrayList<>();
            for (EhsHazardIdentify en : identifies) {
                result.add(EhsHazardIdentifyMapper.MAPPER.entityToDto(en));
            }

            return result;
        }

        return null;
    }

    /**
     * 查询指定单元的危险源辨识记录Entity集合
     *
     * @param unitid    单元ID
     * @param beginTime 起始时间
     * @param endTime   截止时间
     * @return java.util.List<qc.module.ehs.entity.EhsHazardIdentify>
     * @author QuCheng Tech
     * @since 2025/6/13
     */
    public List<EhsHazardIdentify> queryUnitHazardIdentifyEntities(String unitid, Date beginTime, Date endTime) {
        //获取指定单元指定周期的辨识记录
        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsHazardIdentify::getUnitid, unitid).ge(EhsHazardIdentify::getTm, beginTime).le(EhsHazardIdentify::getTm, endTime);
        //排序，先按辨识时间降序（最新的排再前面），再按危险源类别、项目、名称升序
        wrapper.orderByDesc(EhsHazardIdentify::getTm).orderByAsc(EhsHazardIdentify::getCategoryname, EhsHazardIdentify::getProjectname, EhsHazardIdentify::getItemname);
        return repository.selectList(wrapper);
    }

    /**
     * 指定单元全面辨识危险源
     * @param unitid   单元ID
     * @param userId   用户ID
     * @param username 用户名称
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @description 使用单元分类关联的危险源清单作为该单元的危险源清单。
     * 需要判断每一个危险源记录当天是否已有，当天没有记录则新增危险源辨识记录，当天有记录则判断是否已经确认，未确认则直接修改危险源辨识记录。
     * @since 2024/11/5
     */
    public HazardIdentifyOperateResultDto identificationOverAll(String unitid, int userId, String username) throws QCPromptException {

        HazardIdentifyOperateResultDto result = new HazardIdentifyOperateResultDto();
        result.setSuccess(false);

        //1.条件有效性验证
        if (StringUtils.isBlank(unitid)) {
            result.setMsg("指定的单元ID不能为空");
            return result;
        }

        //2.获取指定单元信息
        EhsUnitInfo unitInfo = unitInfoRepository.selectById(unitid);
        if (unitInfo == null) return null;


        //3.根据指定单元的单元分类获取关联的危险源清单
        List<String> hicds = unitcategoryService.getHazardItemIds(unitInfo.getUccd());
        if (CollectionUtils.isEmpty(hicds)) {
            result.setMsg("指定单元的单元分类未关联危险源清单，请手动设置。");
            return result;
        }
        List<TplHazardItemDto> hazardItemDtos = hazarditemService.getItems(hicds);

        //4.定义需要操作(新增/修改)的集合
        List<HazardIdentifyInfoDto> addHazardIdentifys = new ArrayList<>();//需要新增的危险源辨识记录信息集合
        List<HazardIdentifyInfoDto> updateHazardIdentifys = new ArrayList<>();//需要修改的危险源辨识记录信息集合
        Date date = DateUtil.getNowDate();

        int isconfirmCount = 0x0;//已确认的辨识记录数量
        int addCount = 0x0;//新增的辨识记录数量
        int updateCount = 0x0;//修改的辨识记录数量

        //5.循环遍历每一个危险源清单，判断每个危险源辨识记录当天是否已有，已有则判断是否已经确认，未确认则直接修改辨识记录；没有辨识记录则新增辨识记录
        if (CollectionUtils.isNotEmpty(hazardItemDtos)) {
            for (TplHazardItemDto itemDto : hazardItemDtos) {
                //5.1 获取危险源清单的项目信息
                TplHazardProjectDto projectDto = hazardprojectService.getProject(itemDto.getHpjtcd());
                //5.2 获取危险源清单的类别信息
                TplHazardCategoryDto categoryDto = hazardcategoryService.getCategory(projectDto.getHcatcd());

                //5.3 获取指定辨识时间当天的危险源辨识记录，判断辨识记录是否存在，不存在则新增辨识记录，存在则判断辨识记录是否已经确认，未确认则直接进行修改
                EhsHazardIdentify identification = getidentifyDateIdentify(unitInfo.getUnitid(), categoryDto.getHcatcd(),
                        projectDto.getHpjtcd(), itemDto.getHicd(), date);
                if (Objects.nonNull(identification)) {
                    //当天已存在辨识记录，判断是否已经确认，已经确认的不管，未确认的直接修改
                    if (identification.getHasconfirm()) {
                        isconfirmCount++;
                    } else {
                        identification.setTm(date);
                        identification.setHasconfirm(false);
                        identification.setConfirmnewhazard(false);
                        updateHazardIdentifys.add(EhsHazardIdentifyMapper.MAPPER.entityToDto(identification));
                    }
                } else {
                    //当天不存在辨识记录，新增辨识记录
                    HazardIdentifyInfoDto identify = new HazardIdentifyInfoDto();
                    identify.setIdentifyid(IdentifierUtil.randomUUID());
                    identify.setOrgcode(unitInfo.getOrgcode());
                    identify.setTm(DateUtil.getDateTimeString(date));
                    //全面辨识时使用当前登录用户名作为辨识人员
                    identify.setUsername(username);
                    identify.setIntm(DateUtil.getDateTimeString(date));
                    identify.setInuserid(userId);
                    identify.setInusername(username);
                    identify.setUnitid(unitInfo.getUnitid());
                    identify.setUnitname(unitInfo.getUnitname());
                    identify.setCategorycode(categoryDto.getHcatcd());
                    identify.setCategoryname(categoryDto.getHcatnm());
                    identify.setProjectcode(projectDto.getHpjtcd());
                    identify.setProjectname(projectDto.getHpjtnm());
                    identify.setItemcode(itemDto.getHicd());
                    identify.setItemname(itemDto.getHinm());
                    identify.setIsmajor(itemDto.getIsmajor());
                    identify.setCouse(itemDto.getCause());
                    identify.setMaycouseharm(itemDto.getConsequence());
                    //隐患/问题的标题：单元名称+具体部位+危险源+事故诱因
                    identify.setTitle(unitInfo.getUnitname() + itemDto.getHinm() + itemDto.getCause());
                    identify.setDescription(itemDto.getDescription());
                    //危险源辨识结果：默认设置为存在（第一类危险源）,使用EhsHazardIndentificationResultTypeEnum枚举类
                    identify.setIdentificationresult(EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex());
                    identify.setHasconfirm(false);
                    addHazardIdentifys.add(identify);
                }
            }
        }

        //6. 新增/修改危险源辨识记录信息
        if (CollectionUtils.isNotEmpty(addHazardIdentifys)) {
            for (HazardIdentifyInfoDto dto : addHazardIdentifys) {
                add(dto);
                addCount++;
            }
        }
        if (CollectionUtils.isNotEmpty(updateHazardIdentifys)) {
            for (HazardIdentifyInfoDto dto : addHazardIdentifys) {
                update(dto);
                updateCount++;
            }
        }
        String message = "指定单元全面辨识危险源操作成功";
        if (addCount > 0x0) message += "，成功新增" + addCount + "条辨识记录；";
        if (updateCount > 0x0) message += "，成功修改" + updateCount + "条辨识记录；";
        if (isconfirmCount > 0x0) message += "，已存在并确认" + isconfirmCount + "条辨识记录不进行修改操作。";

        result.setSuccess(true);
        result.setMsg(message);
        return result;
    }

    /**
     * 新增危险源辨识记录，用于全面辨识时新增辨识记录
     * @param dto 新增对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/6
     */
    String add(HazardIdentifyInfoDto dto) {
        if (dto == null) return QCUnifyReturnValue.Warn("新增对象不能为空");
        if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("所属组织代码不能为空");
        if (StringUtils.isBlank(dto.getTm())) return QCUnifyReturnValue.Warn("辨识时间不能为空");
        if (StringUtils.isBlank(dto.getUnitid())) return QCUnifyReturnValue.Warn("单元ID不能为空");
        if (StringUtils.isBlank(dto.getUnitname())) return QCUnifyReturnValue.Warn("单元名称不能为空");
        if (StringUtils.isBlank(dto.getTitle())) return QCUnifyReturnValue.Warn("标题不能为空");

        EhsHazardIdentify en = EhsHazardIdentifyMapper.MAPPER.dtoToEntity(dto);
        if (StringUtils.isBlank(dto.getIdentifyid())) {
            en.setIdentifyid(IdentifierUtil.randomUUID());
        }

        if (repository.insert(en) < 0x1) {
            return QCUnifyReturnValue.Warn("保存失败");
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 新增危险源辨识记录
     * 可以用于新增危险源辨识和对已有的危险源辨识进行重新辨识操作；
     * @param dto      新增辨识记录DTO
     * @param userId   用户ID
     * @param username 用户名称
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/6
     */
    public HazardIdentifyOperateResultDto add(HazardIdentifyAddDto dto, int userId, String username)
            throws QCPromptException, ParseException {

        HazardIdentifyOperateResultDto result = new HazardIdentifyOperateResultDto();
        result.setSuccess(false);

        //1.DTO有效性验证
        if (dto == null) {
            result.setMsg("新增危险源辨识记录对象不能为空。");
            return result;
        }
        if (StringUtils.isBlank(dto.getOrgcode())) {
            result.setMsg("所属组织代码不能为空。");
            return result;
        }
        if (StringUtils.isBlank(dto.getTm())) {
            result.setMsg("辨识时间不能为空。");
            return result;
        }
        if (StringUtils.isBlank(dto.getUnitid())) {
            result.setMsg("单元ID不能为空。");
            return result;
        }
        if (StringUtils.isBlank(dto.getUnitname())) {
            result.setMsg("单元名称不能为空。");
            return result;
        }
        if (StringUtils.isBlank(dto.getTitle())) {
            result.setMsg("标题不能为空。");
            return result;
        }

        //2.辨识时间有效性验证：辨识时间不能大于当天，不能小于当前日期前30天。
        Date nowDate = DateUtil.getNowDate();
        Date tm = DateUtil.parseDate(dto.getTm());
        Date on30DayTm = DateUtil.addDays(nowDate, -30);
        if (tm.after(nowDate)) {
            result.setMsg("辨识时间不能大于当天。");
            return result;
        }
        if (tm.before(on30DayTm)) {
            result.setMsg("辨识时间不能小于当前日期前30天。");
            return result;
        }

        //辨识结果转为为枚举类型
        EhsHazardIndentificationResultTypeEnum identificationresult = getEhsHazardIndentificationResultTypeEnum(dto.getIdentificationresult());
        if (identificationresult == null) {
            result.setMsg("辨识结果不正确");
            return result;
        }
        //3.新增/修改危险源辨识记录
        //获取指定辨识时间当天的危险源辨识记录，判断辨识记录是否存在，不存在则新增辨识记录，存在则判断辨识记录是否已经确认，确认则进行提示，未确认则直接进行修改
        EhsHazardIdentify identify = getidentifyDateIdentify(dto.getUnitid(), dto.getCategorycode(), dto.getProjectcode(), dto.getItemcode(), tm);
        if (Objects.nonNull(identify)) {
            if (identify.getHasconfirm()) {
                result.setMsg("新增危险源辨识记录时，此辨识记录辨识时间已存在并且已确认。");
                return result;
            } else {
                identify.setTm(tm);
                identify.setUsername(dto.getUsername());
                identify.setFacilityid(dto.getFacilityid());
                identify.setFacilityname(dto.getFacilityname());
                identify.setIsmajor(dto.isIsmajor());
                identify.setPosition(dto.getPosition());
                identify.setCouse(dto.getCouse());
                identify.setMaycouseharm(dto.getMaycouseharm());
                identify.setTitle(dto.getTitle());
                identify.setDescription(dto.getDescription());
                identify.setAttachment(dto.getAttachment());
                identify.setIdentificationresult(identificationresult);
                identify.setUnsafefactor(dto.getUnsafefactor());
                identify.setTaskitemid(dto.getTaskitemid());
                identify.setTaskitemname(dto.getTaskitemname());
                //设置新增辨识记录中的危险源ID，不管DTO中是否传入危险源ID均进行赋值
                identify.setHazardid(dto.getHazardid());
                identify.setHasconfirm(false);
                identify.setConfirmnewhazard(false);
                repository.updateById(identify);
                result.setMsg("新增危险源辨识记录时，成功修改1条危险源辨识记录。");
            }
        } else {
            //新增辨识记录
            identify = new EhsHazardIdentify();
            identify.setIdentifyid(IdentifierUtil.randomUUID());
            identify.setOrgcode(dto.getOrgcode());
            identify.setTm(tm);
            identify.setUsername(dto.getUsername());
            identify.setIntm(DateUtil.getNowDate());
            identify.setInuserid(userId);
            identify.setInusername(username);
            identify.setUnitid(dto.getUnitid());
            identify.setUnitname(dto.getUnitname());
            identify.setFacilityid(dto.getFacilityid());
            identify.setFacilityname(dto.getFacilityname());
            identify.setCategorycode(dto.getCategorycode());
            identify.setCategoryname(dto.getCategoryname());
            identify.setProjectcode(dto.getProjectcode());
            identify.setProjectname(dto.getProjectname());
            identify.setItemcode(dto.getItemcode());
            identify.setItemname(dto.getItemname());
            identify.setIsmajor(dto.isIsmajor());
            identify.setPosition(dto.getPosition());
            identify.setCouse(dto.getCouse());
            identify.setMaycouseharm(dto.getMaycouseharm());
            identify.setTitle(dto.getTitle());
            identify.setDescription(dto.getDescription());
            identify.setAttachment(dto.getAttachment());
            identify.setIdentificationresult(identificationresult);
            identify.setUnsafefactor(dto.getUnsafefactor());
            identify.setTaskitemid(dto.getTaskitemid());
            identify.setTaskitemname(dto.getTaskitemname());
            //设置新增辨识记录中的危险源ID，不管DTO中是否传入危险源ID均进行赋值
            identify.setHazardid(dto.getHazardid());
            identify.setHasconfirm(false);
            identify.setConfirmnewhazard(false);
            if (repository.insert(identify) < 0x1) {
                result.setMsg("新增危险源辨识记录时，新增失败1条危险源辨识记录。");
                return result;
            }
            result.setMsg("新增危险源辨识记录时，成功新增1条危险源辨识记录。");
        }

        //如果有来源任务ID（任务项ID），更新任务项中的辨识危险源次数、上报隐患次数
        if (StringUtils.isNotBlank(dto.getTaskitemid())) {
            //获取指定任务项
            EhsTaskItem item = taskItemRepository.selectById(dto.getTaskitemid());
            if (Objects.nonNull(item)) {
                //如果对应的任务项存在
                if (dto.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                    //本次新增的辨识结果是第一类危险源
                    item.setExecidentifycount(item.getExecidentifycount() + 0x1);
                } else if (dto.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                    //本次新增的辨识结果是第二类危险源
                    item.setExectroublecount(item.getExectroublecount() + 0x1);
                } else {
                    //本次新增的辨识结果不是第一类或第二类危险源，不进行任何处理
                }
                //更新任务项中的危险源和隐患辨识上报次数
                taskItemRepository.updateById(item);

                //任务项的任务分组和任务的数据统计
                //获取执行任务分组
                EhsTaskGroup group = taskGroupRepository.selectById(item.getGroupid());
                //获取指定任务信息
                EhsTaskInfo taskInfo = taskInfoRepository.selectById(item.getTaskid());
                taskExecService.accountGroup(group);
                taskExecService.accountTask(taskInfo);
            }
        }

        result.setSuccess(true);
        return result;
    }

    EhsHazardIndentificationResultTypeEnum getEhsHazardIndentificationResultTypeEnum(int index) {
        for (EhsHazardIndentificationResultTypeEnum item : EhsHazardIndentificationResultTypeEnum.values()) {
            if (item.getIndex() == index) {//判断序号使用getIndex，判断内容使用getName
                return item;
            }
        }

        return null;
    }

    /**
     * 辨识已存在的危险源无变化
     * @param id       危险源ID
     * @param userId   用户ID
     * @param username 用户名称
     * @return 成功返回null，失败返回错误或提示信息
     * @throws QCPromptException
     * @author QuCheng Tech
     * @description 用于对已有的危险源信息确认无任何变化。点击该按钮弹出确认提示，确认后在危险源辨识记录表中插入一条最新的记录，危险源的信息与危险源的最新数据一致。
     * @since 2024/11/6
     */
    public HazardIdentifyOperateResultDto noChange(String id, int userId, String username) throws QCPromptException {
        HazardIdentifyOperateResultDto result = new HazardIdentifyOperateResultDto();
        result.setSuccess(false);

        //1.获取指定危险源信息
        EhsHazardInfoDto hazardInfoDto = hazardInfoService.get(id);
        if (Objects.isNull(hazardInfoDto)) {
            result.setMsg("辨识已存在的危险源无变化时，指定的危险源信息不存在。");
            return result;
        }

        String message = "";

        //2.查询指定危险源的最新辨识记录信息
        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsHazardIdentify::getHazardid, id)
                .orderByDesc(EhsHazardIdentify::getTm);
        EhsHazardIdentify identify = repository.selectOne(wrapper);
        if (Objects.nonNull(identify)) {
            //根据最新辨识记录信息查询判断当前辨识时间的辨识记录是否存在，不存在则按照最新辨识记录新增一条辨识记录，
            // 存在则判断当前辨识时间的辨识记录是否已经确认，确认则进行提示，未确认则直接进行修改
            Date tm = DateUtil.getNowDate();
            EhsHazardIdentify identification = getidentifyDateIdentify(identify.getUnitid(),
                    identify.getCategorycode(), identify.getProjectcode(), identify.getItemcode(), tm);
            if (Objects.nonNull(identification)) {
                if (identification.getHasconfirm()) {
                    result.setMsg("辨识已存在的危险源无变化时，最新辨识记录已存在并且已确认。");
                    return result;
                } else {
                    identification.setTm(tm);
                    identification.setHasconfirm(false);
                    identification.setConfirmnewhazard(false);
                    repository.updateById(identification);
                    message = "辨识已存在的危险源无变化时，成功修改1条危险源辨识记录。";
                }
            } else {
                //新增辨识记录
                identify.setIdentifyid(IdentifierUtil.randomUUID());
                identify.setTm(tm);
                identify.setIntm(tm);
                identify.setInuserid(userId);
                identify.setInusername(username);
                identify.setHasconfirm(false);
                identify.setConfirmnewhazard(false);
                //使用的新增实体是从数据库中查询出来的结果，对确认结果、时间和确认人信息进行清空
                identify.setConfirmresult(null);
                identify.setConfirmtm(null);
                identify.setConfirmuserid(null);
                identify.setConfirmusername(null);
                identify.setConfirmdescription(null);

                if (repository.insert(identify) < 0x1) {
                    result.setMsg("辨识已存在的危险源无变化时，新增失败1条危险源辨识记录。");
                    return result;
                }
                message = "辨识已存在的危险源无变化时，成功新增1条危险源辨识记录。";
            }

            //3.修改危险源信息中的辨识时间
            hazardInfoDto.setRecentidentificationtm(DateUtil.getDateTimeString(tm));
            hazardInfoService.update(hazardInfoDto);
            message += "成功修改1条危险源信息。";
        }

        result.setSuccess(true);
        result.setMsg(message);
        return result;
    }

    /**
     * 获取指定辨识记录
     * @param id 危险源辨识记录ID
     * @return HazardIdentifyInfoDto
     * @author QuCheng Tech
     * @since 2024/11/8
     */
    public HazardIdentifyInfoDto get(String id) {
        EhsHazardIdentify en = repository.selectById(id);
        if (Objects.nonNull(en)) {
            return EhsHazardIdentifyMapper.MAPPER.entityToDto(en);
        }
        return null;
    }

    /**
     * 修改危险源辨识记录
     * @param dto 修改对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @description 对危险源辨识记录进行修改；需要判断记录是否确认，确认后的危险源辨识记录不能修改；
     * @since 2024/11/6
     */
    public HazardIdentifyOperateResultDto update(HazardIdentifyInfoDto dto) throws QCPromptException {

        HazardIdentifyOperateResultDto result = new HazardIdentifyOperateResultDto();
        result.setSuccess(false);

        //1.DTO有效性验证
        if (dto == null) {
            result.setMsg("修改危险源辨识记录对象不能为空");
            return result;
        }
        if (StringUtils.isBlank(dto.getIdentifyid())) {
            result.setMsg("辨识ID不能为空");
            return result;
        }
        if (StringUtils.isBlank(dto.getOrgcode())) {
            result.setMsg("所属组织代码不能为空");
            return result;
        }
        if (StringUtils.isBlank(dto.getTm())) {
            result.setMsg("辨识时间不能为空");
            return result;
        }
        if (StringUtils.isBlank(dto.getUnitid())) {
            result.setMsg("单元ID不能为空");
            return result;
        }
        if (StringUtils.isBlank(dto.getUnitname())) {
            result.setMsg("单元名称不能为空");
            return result;
        }
        if (StringUtils.isBlank(dto.getTitle())) {
            result.setMsg("标题不能为空");
            return result;
        }

        //辨识时间有效性验证：辨识时间不能大于当天，不能小于当前日期前30天。
        Date nowDate = DateUtil.getNowDate();
        Date tm = DateUtil.parseDate(dto.getTm());
        Date on30DayTm = DateUtil.addDays(nowDate, -30);
        if (tm.after(nowDate)) {
            result.setMsg("辨识时间不能大于当天");
            return result;
        }
        if (tm.before(on30DayTm)) {
            result.setMsg("辨识时间不能小于当前日期前30天");
            return result;
        }

        EhsHazardIdentify identify = repository.selectById(dto.getIdentifyid());
        if (Objects.isNull(identify)) {
            result.setMsg("修改的辨识记录不存在");
            return result;
        }
        if (identify.getHasconfirm()) {
            result.setMsg("修改危险源辨识记录操作时，辨识记录已确认，不能进行修改操作。");
            return result;
        }

        //获取指定辨识时间当天的危险源辨识记录，判断辨识记录是否存在，不存在则新增辨识记录，存在则判断辨识记录是否已经确认，确认则进行提示，未确认则直接进行修改
        EhsHazardIdentify identification = getidentifyDateIdentify(dto.getUnitid(), dto.getCategorycode(), dto.getProjectcode(), dto.getItemcode(), tm);
        if (Objects.nonNull(identification)) {
            if (identification.getHasconfirm()) {
                result.setMsg("修改危险源辨识记录操作时，修改后的辨识记录已存在并且已确认，不进行修改操作。");
                return result;
            }
        }

        EhsHazardIdentify en = EhsHazardIdentifyMapper.MAPPER.dtoToEntity(dto);
        //设置修改的辨识记录中的危险源ID，不管DTO中是否传入危险源ID均进行赋值
        en.setHazardid(dto.getHazardid());
        en.setTm(tm);
        repository.updateById(en);
        result.setMsg("修改危险源辨识记录操作时，成功修改1条危险源辨识记录。");

        //如果有来源任务ID（任务项ID），更新任务项中的辨识危险源次数、上报隐患次数
        if (StringUtils.isNotBlank(dto.getTaskitemid())) {
            //获取指定任务项
            EhsTaskItem item = taskItemRepository.selectById(dto.getTaskitemid());
            if (dto.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                item.setExecidentifycount(item.getExecidentifycount() + 0x1);

                taskItemRepository.updateById(item);
            } else if (dto.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                item.setExectroublecount(item.getExectroublecount() + 0x1);

                taskItemRepository.updateById(item);
            } else {
                //辨识结果不为存在第一类危险源或存在第二类危险源，不需要更新任务项中的辨识危险源或上报隐患的次数
            }

            //任务项的任务分组和任务的数据统计
            //获取执行任务分组
            EhsTaskGroup group = taskGroupRepository.selectById(item.getGroupid());
            //获取指定任务信息
            EhsTaskInfo taskInfo = taskInfoRepository.selectById(item.getTaskid());
            taskExecService.accountGroup(group);
            taskExecService.accountTask(taskInfo);
        }

        result.setSuccess(true);
        return result;
    }

    /**
     * 删除危险源辨识记录
     * @param id 辨识ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @description 对危险源辨识记录进行删除；需要判断记录是否确认，确认后的危险源辨识记录不能删除；
     * @since 2024/11/6
     */
    public HazardIdentifyOperateResultDto delete(String id) {
        HazardIdentifyOperateResultDto result = new HazardIdentifyOperateResultDto();
        result.setSuccess(false);

        EhsHazardIdentify en = repository.selectById(id);
        if (Objects.nonNull(en)) {
            if (en.getHasconfirm()) {
                result.setMsg("删除危险源辨识记录操作时，辨识记录已确认，不进行删除操作。");
                return result;
            }
        }

        //如果有来源任务ID（任务项ID），更新任务项中的辨识危险源次数、上报隐患次数
        if (StringUtils.isNotBlank(en.getTaskitemid())) {
            //获取指定任务项
            EhsTaskItem item = taskItemRepository.selectById(en.getTaskitemid());
            if (en.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD) {
                item.setExecidentifycount(item.getExecidentifycount() - 0x1);
            } else if (en.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE) {
                item.setExectroublecount(item.getExectroublecount() - 0x1);
            } else {
                //辨识结果不为存在第一类或存在第二类时，不需要进行任何处理
            }

            taskItemRepository.updateById(item);

            //任务项的任务分组和任务的数据统计
            //获取执行任务分组
            EhsTaskGroup group = taskGroupRepository.selectById(item.getGroupid());
            //获取指定任务信息
            EhsTaskInfo taskInfo = taskInfoRepository.selectById(item.getTaskid());
            taskExecService.accountGroup(group);
            taskExecService.accountTask(taskInfo);
        }

        repository.deleteById(id);

        result.setSuccess(true);
        result.setMsg("删除危险源辨识记录操作成功。");
        return result;
    }

    /**
     * 确认辨识的危险源记录
     * @param dto      危险源辨识记录确认DTO
     * @param userId   用户ID
     * @param username 用户名称
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @description 对指定的危险源辨识记录进行确认；确认后需要根据确认的结果对危险源信息表数据进行更新；确认操作可以多次进行，已防止误操作时对已有数据进行修改；
     * 如传入危险源ID表示确认辨识记录对应的危险源ID为传入值，如未传入危险源ID先根据辨识记录新增1个危险源信息再进行关联；
     * 注意：需要根据危险源辨识记录表中的已有危险源ID和传入的危险源ID进行判断，可能存在本次设置的危险源ID与上次设置的危险源ID不一致的情况，会导致危险源信息表中的危险源信息错误；
     * @since 2024/11/6
     */
    public HazardIdentifyConfirmResultDto confirm(HazardIdentifyConfirmDto dto, int userId, String username) throws QCPromptException {
        //1.定义返回结果对象
        HazardIdentifyConfirmResultDto result = new HazardIdentifyConfirmResultDto();
        result.setSuccess(false);
        result.setIdentifyid(dto.getIdentifyid());

        //2.DTO有效性验证
        if (dto == null) {
            result.setMsg("确认信息对象不能为空");
            return result;
        }
        if (StringUtils.isBlank(dto.getIdentifyid())) {
            result.setMsg("辨识记录ID不能为空");
            return result;
        }

        //获取传入的确认辨识结果枚举值，判断是否正确
        EhsHazardIndentificationResultTypeEnum confirmIndentificationResult = getEhsHazardIndentificationResultTypeEnum(dto.getConfirmresult());
        if (confirmIndentificationResult == null) {
            result.setMsg("确认的辨识结果不正确");
            return result;
        }

        //3.获取指定要确认辨识记录
        EhsHazardIdentify confirmIdentify = repository.selectById(dto.getIdentifyid());
        if (Objects.isNull(confirmIdentify)) {
            result.setMsg("指定确认的辨识记录不存在。");
            return result;
        }

        //4.获取指定单元信息，统计更新单元信息数量
        EhsUnitInfo unitInfo = unitInfoRepository.selectById(confirmIdentify.getUnitid());
        Integer general1 = unitInfo.getGeneral1() == null ? 0x0 : unitInfo.getGeneral1(),
                major1 = unitInfo.getMajor1() == null ? 0x0 : unitInfo.getMajor1(),
                general2 = unitInfo.getGeneral2() == null ? 0x0 : unitInfo.getGeneral2(),
                major2 = unitInfo.getMajor2() == null ? 0x0 : unitInfo.getMajor2();

        String confirmHazardId = "";//最后确认的危险源ID
        boolean isNewHazard = false;//是否是新增危险源
        String message = "确认危险源辨识记录操作时，";

        //5.判断是否有传入的危险源ID
        if (StringUtils.isBlank(dto.getHazardid())) {
            //5.1 没有传入危险源ID的情况处理：
            //根据辨识记录查询危险源信息是否已有（根据单元ID、所属危险源类别代码、项目代码、清单代码查询）
            EhsHazardInfoDto hazard = hazardInfoService.getByUnitIdAndItemId(confirmIdentify.getUnitid(),
                    confirmIdentify.getCategorycode(), confirmIdentify.getProjectcode(), confirmIdentify.getItemcode());
            if (Objects.nonNull(hazard)) {
                //如果已有危险源：
                /*判断本次确认的辨识记录是否为最新的辨识记录，如果辨识时间不为最新仅对危险源辨识记录表中的确认信息进行修改，
                    不对危险源信息表和隐患治理表进行操作。判断条件为：“危险源信息表”中记录的“最近辨识时间”≤“危险源辨识记录表”中的“辨识时间”表示确认的辨识记录为最新辨识记录。
                */
                if (!DateUtil.parseDate(hazard.getRecentidentificationtm()).after(confirmIdentify.getTm())) {
                    //（1）统计单元信息数量：根据修改前危险源的辨识结果判断为第一类危险源还是第二类危险源，再统计一般/重大数量：原数量 - 1
                    EhsHazardIndentificationResultTypeEnum existHazardIdentificationresult = getEhsHazardIndentificationResultTypeEnum(hazard.getIdentificationresult());
                    if (existHazardIdentificationresult != null) {
                        if (hazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                            //修改前为第一类危险源
                            if (hazard.isIsmajor()) major1 -= 0x1;
                            else general1 -= 0x1;
                        } else if (hazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                            //修改前为第二类危险源
                            if (hazard.isIsmajor()) major2 -= 0x1;
                            else general2 -= 0x1;
                        } else {
                            //不存在：不统计
                        }
                    }

                    //（2）判断确认的辨识结果：操作隐患治理记录
                    if ((hazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST.getIndex()
                            || hazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) &&
                            dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()
                    ) {
                        //确认结果为不存在/第一类 -> 第二类：新增隐患治理记录；隐患治理表”中的“发现时间”使用“危险源辨识记录表”中的“辨识时间”。
                        /*是否需要新增隐患治理记录：
                          a.判断本次确认的辨识记录是否为最新的辨识记录，是则新增；
                          b.确认结果为第二类危险源（隐患）;
                          c.对应的隐患ID（不管辨识时间）在“隐患治理表”中不存在任何记录或存在的最新记录状态
                            为“已整改完成”并且“验收通过”（表示之前相同的隐患已治理）新增隐患治理记录。
                         */
                        //获取指定隐患最新隐患治理记录
                        EhsTroubleCorrectInfoDto troubleDto = troubleCorrectService.getByHazardId(hazard.getHazardid());
                        if ((Objects.isNull(troubleDto) || (troubleDto.isHascorrect() && troubleDto.isHascheck()))) {
                            EhsTroubleCorrectInfoDto trouble = new EhsTroubleCorrectInfoDto();
                            trouble.setHazardid(hazard.getHazardid());
                            trouble.setOrgcode(confirmIdentify.getOrgcode());
                            trouble.setTm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                            trouble.setUnitid(confirmIdentify.getUnitid());
                            trouble.setUnit(confirmIdentify.getUnitname());
                            trouble.setFacilityid(confirmIdentify.getFacilityid());
                            trouble.setFacilityname(confirmIdentify.getFacilityname());
                            trouble.setCategorycode(confirmIdentify.getCategorycode());
                            trouble.setCategoryname(confirmIdentify.getCategoryname());
                            trouble.setProjectcode(confirmIdentify.getProjectcode());
                            trouble.setProjectname(confirmIdentify.getProjectname());
                            trouble.setItemcode(confirmIdentify.getItemcode());
                            trouble.setItemname(confirmIdentify.getItemname());
                            trouble.setIsmajor(confirmIdentify.getIsmajor());
                            trouble.setPosition(confirmIdentify.getPosition());
                            trouble.setCouse(confirmIdentify.getCouse());
                            trouble.setMaycouseharm(confirmIdentify.getMaycouseharm());
                            trouble.setTitle(confirmIdentify.getTitle());
                            trouble.setDescription(confirmIdentify.getDescription());
                            trouble.setAttachment(confirmIdentify.getAttachment());
                            trouble.setUnsafefactor(confirmIdentify.getUnsafefactor());
                            trouble.setIsreport(false);//默认不上报
                            trouble.setHasdispatch(false);
                            trouble.setHascorrect(false);
                            trouble.setHascheck(false);
                            trouble.setRisklevel(hazard.getRisklevel());
                            //整改责任部门和整改负责人信息从危险源信息中获取写入；
                            trouble.setResdeptid(hazard.getResdeptid());
                            trouble.setResdeptname(hazard.getResdeptname());
                            trouble.setResuserid(hazard.getResuserid());
                            trouble.setResusername(hazard.getResusername());
                            trouble.setResuserphone(hazard.getResuserphone());
                            troubleCorrectService.add(trouble);
                            message += "成功新增1条隐患治理记录；";
                        }

                    } else if (hazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex() &&
                            (dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST.getIndex()
                                    || dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex())
                    ) {
                        //确认结果为 第二类 -> 不存在/第一类：删除上次操作新增隐患治理记录处理。
                        EhsTroubleCorrectInfoDto lastTroubleDto = troubleCorrectService.getByHazardIdAnDTm(hazard.getHazardid(), confirmIdentify.getTm());
                        if (Objects.nonNull(lastTroubleDto)) {
                            troubleCorrectService.delete(lastTroubleDto.getCorrectid());
                            message += "成功删除1条隐患治理记录；";
                        }
                    } else {
                        //不处理
                    }

                    //（3）修改危险源信息：辨识结果为确认的辨识结果、辨识时间为辨识记录的辨识时间
                    hazard.setIdentificationresult(dto.getConfirmresult());
                    hazard.setRecentidentificationtm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                    hazardInfoService.update(hazard);
                    confirmHazardId = hazard.getHazardid();
                    isNewHazard = false;
                    message += "成功修改1条危险源信息；";
                }
            } else {
                //（1）如果没有危险源，新增危险源信息，判断确认结果为第二类则新增隐患治理记录
                hazard = new EhsHazardInfoDto();
                hazard.setHazardid(IdentifierUtil.randomUUID());
                hazard.setOrgcode(confirmIdentify.getOrgcode());
                hazard.setHazardname(confirmIdentify.getItemname());
                hazard.setUnitid(confirmIdentify.getUnitid());
                hazard.setUnitname(confirmIdentify.getUnitname());
                hazard.setFacilityid(confirmIdentify.getFacilityid());
                hazard.setFacilityname(confirmIdentify.getFacilityname());
                hazard.setCategorycode(confirmIdentify.getCategorycode());
                hazard.setCategoryname(confirmIdentify.getCategoryname());
                hazard.setProjectcode(confirmIdentify.getProjectcode());
                hazard.setProjectname(confirmIdentify.getProjectname());
                hazard.setItemcode(confirmIdentify.getItemcode());
                hazard.setItemname(confirmIdentify.getItemname());
                hazard.setIsmajor(confirmIdentify.getIsmajor());
                hazard.setPosition(confirmIdentify.getPosition());
                hazard.setCouse(confirmIdentify.getCouse());
                hazard.setMaycouseharm(confirmIdentify.getMaycouseharm());
                hazard.setTitle(confirmIdentify.getTitle());
                hazard.setDescription(confirmIdentify.getDescription());
                hazard.setAttachment(confirmIdentify.getAttachment());
                hazard.setIdentificationresult(dto.getConfirmresult());//危险源辨识结果保存为确认的辨识结果
                hazard.setUnsafefactor(confirmIdentify.getUnsafefactor());
                hazard.setRecentidentificationtm(DateUtil.getDateTimeString(confirmIdentify.getTm()));//最近辨识时间保存为辨识记录的辨识时间
                hazard.setIsreport(false);//默认不上报
                //责任部门与责任人信息从单元中获取设置
                hazard.setResdeptid(unitInfo.getResdeptid());
                hazard.setResdeptname(unitInfo.getResdeptname());
                hazard.setResuserid(unitInfo.getResuserid());
                hazard.setResusername(unitInfo.getResusername());
                hazard.setResuserphone(unitInfo.getResuserphone());
                hazardInfoService.add(hazard);
                confirmHazardId = hazard.getHazardid();
                isNewHazard = true;
                message += "成功新增1条危险源信息；";

                //（2）如果确认的辨识结果为第二类，新增隐患治理记录（根据辨识记录新增）
                if (isNewHazard && dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                    EhsTroubleCorrectInfoDto trouble = new EhsTroubleCorrectInfoDto();
                    trouble.setHazardid(hazard.getHazardid());
                    trouble.setOrgcode(confirmIdentify.getOrgcode());
                    trouble.setTm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                    trouble.setUnitid(confirmIdentify.getUnitid());
                    trouble.setUnit(confirmIdentify.getUnitname());
                    trouble.setFacilityid(confirmIdentify.getFacilityid());
                    trouble.setFacilityname(confirmIdentify.getFacilityname());
                    trouble.setCategorycode(confirmIdentify.getCategorycode());
                    trouble.setCategoryname(confirmIdentify.getCategoryname());
                    trouble.setProjectcode(confirmIdentify.getProjectcode());
                    trouble.setProjectname(confirmIdentify.getProjectname());
                    trouble.setItemcode(confirmIdentify.getItemcode());
                    trouble.setItemname(confirmIdentify.getItemname());
                    trouble.setIsmajor(confirmIdentify.getIsmajor());
                    trouble.setPosition(confirmIdentify.getPosition());
                    trouble.setCouse(confirmIdentify.getCouse());
                    trouble.setMaycouseharm(confirmIdentify.getMaycouseharm());
                    trouble.setTitle(confirmIdentify.getTitle());
                    trouble.setDescription(confirmIdentify.getDescription());
                    trouble.setAttachment(confirmIdentify.getAttachment());
                    trouble.setUnsafefactor(confirmIdentify.getUnsafefactor());
                    trouble.setIsreport(false);//默认不上报
                    trouble.setHasdispatch(false);
                    trouble.setHascorrect(false);
                    trouble.setHascheck(false);
                    //整改责任部门和整改负责人信息从危险源信息中获取写入；
                    trouble.setResdeptid(hazard.getResdeptid());
                    trouble.setResdeptname(hazard.getResdeptname());
                    trouble.setResuserid(hazard.getResuserid());
                    trouble.setResusername(hazard.getResusername());
                    trouble.setResuserphone(hazard.getResuserphone());
                    troubleCorrectService.add(trouble);
                    message += "成功新增1条隐患治理记录；";
                }
            }

        } else {
            //5.2 有传入危险源ID的情况处理：
            //1.获取指定传入的危险源信息confirmHazard
            EhsHazardInfoDto confirmHazard = hazardInfoService.get(dto.getHazardid());
            //2.判断确认的辨识记录中是否已经确认过（确认过则表示辨识记录中已存在确认的辨识结果和危险源ID，未确认过则表示辨识记录中确认的辨识结果和危险源ID为空）
            if (confirmIdentify.getHasconfirm()) {
                //2.1 辨识记录重复多次确认的情况（辨识记录已有确认信息，关联的危险源ID）
                //判断传入的危险源ID与辨识记录中已有的危险源ID是否一致
                if (dto.getHazardid().equals(confirmIdentify.getHazardid())) {
                    //危险源ID一致的情况：判断传入确认的辨识结果与辨识记录中已有确认的辨识结果是否一致
                    if (confirmIndentificationResult == confirmIdentify.getConfirmresult()) {
                        //情况1：危险源ID一致，确认结果一致：结果未变化，不进行任何操作。
                    } else {
                        //情况2：危险源ID一致，确认结果不一致（确认的危险源信息存在）
                        /*判断本次确认的辨识记录是否为最新的辨识记录，如果辨识时间不为最新仅对危险源辨识记录表中的确认信息进行修改，
                            不对危险源信息表和隐患治理表进行操作。判断条件为：“危险源信息表”中记录的“最近辨识时间”≤“危险源辨识记录表”中的“辨识时间”表示确认的辨识记录为最新辨识记录。
                        */
                        if (!DateUtil.parseDate(confirmHazard.getRecentidentificationtm()).after(confirmIdentify.getTm())) {
                            //（1）统计单元信息数量：根据修改前危险源的辨识结果判断为第一类危险源还是第二类危险源，再统计一般/重大数量：原数量 - 1
                            if (confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                //原记录为第一类危险源
                                if (confirmHazard.isIsmajor()) major1 -= 0x1;
                                else general1 -= 0x1;
                            } else if (confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                //原记录为第二类危险源
                                if (confirmHazard.isIsmajor()) major2 -= 0x1;
                                else general2 -= 0x1;
                            } else {
                                //不适用/不存在
                            }

                            //（2）判断辨识结果：操作隐患治理记录
                            if ((confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST.getIndex()
                                    || confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) &&
                                    dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()
                            ) {
                                //确认结果为不存在/第一类 -> 第二类：新增隐患治理记录；隐患治理表”中的“发现时间”使用“危险源辨识记录表”中的“辨识时间”。
                                /*是否需要新增隐患治理记录：
                                  a.判断本次确认的辨识记录是否为最新的辨识记录，是则新增；
                                  b.确认结果为第二类危险源（隐患）;
                                  c.对应的隐患ID（不管辨识时间）在“隐患治理表”中不存在任何记录或存在的最新记录状态
                                    为“已整改完成”并且“验收通过”（表示之前相同的隐患已治理）新增隐患治理记录。
                                 */
                                //获取指定隐患最新隐患治理记录
                                EhsTroubleCorrectInfoDto troubleDto = troubleCorrectService.getByHazardId(confirmHazard.getHazardid());
                                if ((Objects.isNull(troubleDto) || (troubleDto.isHascorrect() == true && troubleDto.isHascheck() == true))) {
                                    EhsTroubleCorrectInfoDto trouble = new EhsTroubleCorrectInfoDto();
                                    trouble.setHazardid(confirmHazard.getHazardid());
                                    trouble.setOrgcode(confirmIdentify.getOrgcode());
                                    trouble.setTm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                                    trouble.setUnitid(confirmIdentify.getUnitid());
                                    trouble.setUnit(confirmIdentify.getUnitname());
                                    trouble.setFacilityid(confirmIdentify.getFacilityid());
                                    trouble.setFacilityname(confirmIdentify.getFacilityname());
                                    trouble.setCategorycode(confirmIdentify.getCategorycode());
                                    trouble.setCategoryname(confirmIdentify.getCategoryname());
                                    trouble.setProjectcode(confirmIdentify.getProjectcode());
                                    trouble.setProjectname(confirmIdentify.getProjectname());
                                    trouble.setItemcode(confirmIdentify.getItemcode());
                                    trouble.setItemname(confirmIdentify.getItemname());
                                    trouble.setIsmajor(confirmIdentify.getIsmajor());
                                    trouble.setPosition(confirmIdentify.getPosition());
                                    trouble.setCouse(confirmIdentify.getCouse());
                                    trouble.setMaycouseharm(confirmIdentify.getMaycouseharm());
                                    trouble.setTitle(confirmIdentify.getTitle());
                                    trouble.setDescription(confirmIdentify.getDescription());
                                    trouble.setAttachment(confirmIdentify.getAttachment());
                                    trouble.setUnsafefactor(confirmIdentify.getUnsafefactor());
                                    trouble.setIsreport(false);//默认不上报
                                    trouble.setHasdispatch(false);
                                    trouble.setHascorrect(false);
                                    trouble.setHascheck(false);
                                    trouble.setRisklevel(confirmHazard.getRisklevel());
                                    //整改责任部门和整改负责人信息从危险源信息中获取写入；
                                    trouble.setResdeptid(confirmHazard.getResdeptid());
                                    trouble.setResdeptname(confirmHazard.getResdeptname());
                                    trouble.setResuserid(confirmHazard.getResuserid());
                                    trouble.setResusername(confirmHazard.getResusername());
                                    trouble.setResuserphone(confirmHazard.getResuserphone());
                                    troubleCorrectService.add(trouble);
                                    message += "成功新增1条隐患治理记录；";
                                }

                            } else if (confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex() &&
                                    (dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST.getIndex()
                                            || dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex())
                            ) {
                                //确认结果为 第二类 -> 不存在/第一类：删除上次操作新增隐患治理记录处理。
                                EhsTroubleCorrectInfoDto lastTroubleDto = troubleCorrectService.getByHazardIdAnDTm(confirmIdentify.getHazardid(), confirmIdentify.getTm());
                                if (Objects.nonNull(lastTroubleDto)) {
                                    troubleCorrectService.delete(lastTroubleDto.getCorrectid());
                                    message += "成功删除1条隐患治理记录；";
                                }
                            } else {
                                //不处理
                            }

                            //（3）修改危险源信息：辨识结果为确认的辨识结果、辨识时间为辨识记录的辨识时间
                            confirmHazard.setIdentificationresult(dto.getConfirmresult());
                            confirmHazard.setRecentidentificationtm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                            hazardInfoService.update(confirmHazard);
                            confirmHazardId = confirmHazard.getHazardid();
                            isNewHazard = false;
                            message += "成功修改1条危险源信息；";
                        }
                    }
                } else {
                    //危险源ID不一致的情况：
                    //获取辨识记录中上次操作的危险源信息
                    EhsHazardInfoDto lastHazard = hazardInfoService.get(confirmIdentify.getHazardid());
                    //判断传入确认的辨识结果与辨识记录中已有确认的辨识结果是否一致
                    if (confirmIndentificationResult == confirmIdentify.getConfirmresult()) {
                        //情况1：危险源ID不一致，确认结果一致
                        /*判断本次确认的辨识记录是否为最新的辨识记录，如果辨识时间不为最新仅对危险源辨识记录表中的确认信息进行修改，
                            不对危险源信息表和隐患治理表进行操作。判断条件为：“危险源信息表”中记录的“最近辨识时间”≤“危险源辨识记录表”中的“辨识时间”表示确认的辨识记录为最新辨识记录。
                        */
                        if (!DateUtil.parseDate(confirmHazard.getRecentidentificationtm()).after(confirmIdentify.getTm())) {
                            //判断确认的辨识结果：处理操作危险源信息或隐患治理记录信息
                            if (dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST.getIndex()
                                    || dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                //确认的辨识结果为不存在/第一类：
                                //(1)根据上次操作的危险源的辨识结果判断当前危险源为第一类危险源还是第二类危险源，再统计一般/重大数量：原数量 - 1
                                if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                    //原记录为第一类危险源
                                    if (lastHazard.isIsmajor()) major1 -= 0x1;
                                    else general1 -= 0x1;
                                } else if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                    //原记录为第二类危险源
                                    if (lastHazard.isIsmajor()) major2 -= 0x1;
                                    else general2 -= 0x1;
                                } else {
                                    //不适用/不存在
                                }

                                //(2)修改上次操作危险源ID的记录：恢复“危险源信息表”中的信息。
                                //判断上次操作的危险源是否是新增
                                if (confirmIdentify.getConfirmnewhazard()) {
                                    //上次操作的危险源是新增的危险源，删除上次操作的危险源信息
                                    repository.deleteById(lastHazard.getHazardid());
                                } else {
                                    //上次操作的危险源不是新增的危险源
                                    //从“危险源辨识记录表”中查询本次确认的上一条已确认的最新辨识记录，根据此辨识记录恢复上次操作的危险源信息。
                                    LambdaQueryWrapper<EhsHazardIdentify> identifyWrapper = new LambdaQueryWrapper<>();
                                    identifyWrapper.le(EhsHazardIdentify::getTm, confirmIdentify.getTm())
                                            .eq(EhsHazardIdentify::getHasconfirm, true)
                                            .orderByDesc(EhsHazardIdentify::getTm);
                                    EhsHazardIdentify lastIdentify = repository.selectOne(identifyWrapper);
                                    if (Objects.nonNull(lastIdentify)) {
                                        lastHazard.setIdentificationresult(lastIdentify.getConfirmresult().getIndex());
                                        lastHazard.setRecentidentificationtm(DateUtil.getDateTimeString(lastIdentify.getTm()));
                                        hazardInfoService.update(lastHazard);
                                        message += "成功恢复1条危险源信息；";

                                        //根据上次操作的危险源信息恢复后的结果计算单元统计数量+1；
                                        if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                            //原记录为第一类危险源
                                            if (lastHazard.isIsmajor()) major1 += 0x1;
                                            else general1 += 0x1;
                                        } else if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                            //原记录为第二类危险源
                                            if (lastHazard.isIsmajor()) major2 += 0x1;
                                            else general2 += 0x1;
                                        } else {
                                            //不适用/不存在
                                        }
                                    } else {
                                        //没有上一条确认的辨识记录，删除上次操作的危险源信息
                                        repository.deleteById(lastHazard.getHazardid());
                                    }
                                }

                                //(3)修改本次操作危险源ID的记录：修改“危险源信息表“。
                                confirmHazard.setIdentificationresult(dto.getConfirmresult());//危险源辨识结果保存为确认的辨识结果
                                hazardInfoService.update(confirmHazard);
                                confirmHazardId = confirmHazard.getHazardid();
                                isNewHazard = false;
                                message += "成功修改1条危险源信息；";

                            } else if (dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                //确认的辨识结果为第二类：
                                //(1)修改上次操作危险源ID的记录：删除上次操作新增隐患治理记录处理。
                                EhsTroubleCorrectInfoDto lastTroubleDto = troubleCorrectService.getByHazardIdAnDTm(confirmIdentify.getHazardid(), confirmIdentify.getTm());
                                if (Objects.nonNull(lastTroubleDto)) {
                                    troubleCorrectService.delete(lastTroubleDto.getCorrectid());
                                    message += "成功删除1条隐患治理记录；";
                                }

                                //(2)修改本次操作危险源ID的记录：新增隐患治理记录处理。隐患治理表”中的“发现时间”使用“危险源辨识记录表”中的“辨识时间”。
                                /*是否需要新增隐患治理记录：
                                    a.判断本次确认的辨识记录是否为最新的辨识记录，是则新增；
                                    b.确认结果为第二类危险源（隐患）;
                                    c.对应的隐患ID（不管辨识时间）在“隐患治理表”中不存在任何记录或存在的最新记录状态
                                      为“已整改完成”并且“验收通过”（表示之前相同的隐患已治理）新增隐患治理记录。
                                */
                                //获取指定隐患最新隐患治理记录
                                EhsTroubleCorrectInfoDto troubleDto = troubleCorrectService.getByHazardId(confirmHazard.getHazardid());
                                if ((Objects.isNull(troubleDto) || (troubleDto.isHascorrect() == true && troubleDto.isHascheck() == true))) {
                                    EhsTroubleCorrectInfoDto trouble = new EhsTroubleCorrectInfoDto();
                                    trouble.setHazardid(confirmHazard.getHazardid());
                                    trouble.setOrgcode(confirmIdentify.getOrgcode());
                                    trouble.setTm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                                    trouble.setUnitid(confirmIdentify.getUnitid());
                                    trouble.setUnit(confirmIdentify.getUnitname());
                                    trouble.setFacilityid(confirmIdentify.getFacilityid());
                                    trouble.setFacilityname(confirmIdentify.getFacilityname());
                                    trouble.setCategorycode(confirmIdentify.getCategorycode());
                                    trouble.setCategoryname(confirmIdentify.getCategoryname());
                                    trouble.setProjectcode(confirmIdentify.getProjectcode());
                                    trouble.setProjectname(confirmIdentify.getProjectname());
                                    trouble.setItemcode(confirmIdentify.getItemcode());
                                    trouble.setItemname(confirmIdentify.getItemname());
                                    trouble.setIsmajor(confirmIdentify.getIsmajor());
                                    trouble.setPosition(confirmIdentify.getPosition());
                                    trouble.setCouse(confirmIdentify.getCouse());
                                    trouble.setMaycouseharm(confirmIdentify.getMaycouseharm());
                                    trouble.setTitle(confirmIdentify.getTitle());
                                    trouble.setDescription(confirmIdentify.getDescription());
                                    trouble.setAttachment(confirmIdentify.getAttachment());
                                    trouble.setUnsafefactor(confirmIdentify.getUnsafefactor());
                                    trouble.setIsreport(false);//默认不上报
                                    trouble.setHasdispatch(false);
                                    trouble.setHascorrect(false);
                                    trouble.setHascheck(false);
                                    trouble.setRisklevel(confirmHazard.getRisklevel());
                                    //整改责任部门和整改负责人信息从危险源信息中获取写入；
                                    trouble.setResdeptid(confirmHazard.getResdeptid());
                                    trouble.setResdeptname(confirmHazard.getResdeptname());
                                    trouble.setResuserid(confirmHazard.getResuserid());
                                    trouble.setResusername(confirmHazard.getResusername());
                                    trouble.setResuserphone(confirmHazard.getResuserphone());
                                    troubleCorrectService.add(trouble);
                                    message += "成功新增1条隐患治理记录；";
                                }
                            } else {
                                //不处理
                            }

                            //（3）修改本次操作危险源ID的记录：修改“危险源信息表“。
                            confirmHazard.setIdentificationresult(dto.getConfirmresult());//危险源辨识结果保存为确认的辨识结果
                            hazardInfoService.update(confirmHazard);
                            confirmHazardId = confirmHazard.getHazardid();
                            isNewHazard = false;
                            message += "成功修改1条危险源信息；";
                        }
                    } else {
                        //情况2：危险源ID不一致，确认结果不一致
                        /*判断本次确认的辨识记录是否为最新的辨识记录，如果辨识时间不为最新仅对危险源辨识记录表中的确认信息进行修改，
                            不对危险源信息表和隐患治理表进行操作。判断条件为：“危险源信息表”中记录的“最近辨识时间”≤“危险源辨识记录表”中的“辨识时间”表示确认的辨识记录为最新辨识记录。
                        */
                        if (!DateUtil.parseDate(confirmHazard.getRecentidentificationtm()).after(confirmIdentify.getTm())) {
                            //判断确认的辨识结果：操作隐患治理记录
                            if (confirmIdentify.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE &&
                                    (dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST.getIndex()
                                            || dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex())
                            ) {
                                //确认结果为 第二类 -> 不存在/第一类：
                                //（1）上次操作危险源ID的记录：删除上次操作新增隐患治理记录处理。
                                EhsTroubleCorrectInfoDto lastTroubleDto = troubleCorrectService.getByHazardIdAnDTm(confirmIdentify.getHazardid(), confirmIdentify.getTm());
                                if (Objects.nonNull(lastTroubleDto)) {
                                    troubleCorrectService.delete(lastTroubleDto.getCorrectid());
                                    message += "成功删除1条隐患治理记录；";
                                }

                                // (2)恢复“危险源信息表”中的信息。
                                //根据上次操作的危险源的辨识结果判断当前危险源为第一类危险源还是第二类危险源，再统计一般/重大数量：原数量 - 1
                                if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                    //原记录为第一类危险源
                                    if (lastHazard.isIsmajor()) major1 -= 0x1;
                                    else general1 -= 0x1;
                                } else if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                    //原记录为第二类危险源
                                    if (lastHazard.isIsmajor()) major2 -= 0x1;
                                    else general2 -= 0x1;
                                } else {
                                    //不适用/不存在
                                }

                                //判断上次操作的危险源是否是新增
                                if (confirmIdentify.getConfirmnewhazard()) {
                                    //上次操作的危险源是新增的危险源，删除上次操作的危险源信息
                                    repository.deleteById(lastHazard.getHazardid());
                                } else {
                                    //上次操作的危险源不是新增的危险源
                                    //从“危险源辨识记录表”中查询本次确认的上一条已确认的最新辨识记录，根据此辨识记录恢复上次操作的危险源信息。
                                    LambdaQueryWrapper<EhsHazardIdentify> identifyWrapper = new LambdaQueryWrapper<>();
                                    identifyWrapper.le(EhsHazardIdentify::getTm, confirmIdentify.getTm())
                                            .eq(EhsHazardIdentify::getHasconfirm, true)
                                            .orderByDesc(EhsHazardIdentify::getTm);
                                    EhsHazardIdentify lastIdentify = repository.selectOne(identifyWrapper);
                                    if (Objects.nonNull(lastIdentify)) {
                                        lastHazard.setIdentificationresult(lastIdentify.getConfirmresult().getIndex());
                                        lastHazard.setRecentidentificationtm(DateUtil.getDateTimeString(lastIdentify.getTm()));
                                        hazardInfoService.update(lastHazard);
                                        message += "成功恢复1条危险源信息；";

                                        //根据上次操作的危险源信息恢复后的结果计算单元统计数量+1；
                                        if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                            //原记录为第一类危险源
                                            if (lastHazard.isIsmajor()) major1 += 0x1;
                                            else general1 += 0x1;
                                        } else if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                            //原记录为第二类危险源
                                            if (lastHazard.isIsmajor()) major2 += 0x1;
                                            else general2 += 0x1;
                                        } else {
                                            //不适用/不存在
                                        }
                                    } else {
                                        //没有上一条确认的辨识记录，删除上次操作的危险源信息
                                        repository.deleteById(lastHazard.getHazardid());
                                    }
                                }

                                //(4)修改本次操作危险源ID的记录：修改“危险源信息表“。
                                confirmHazard.setIdentificationresult(dto.getConfirmresult());//危险源辨识结果保存为确认的辨识结果
                                hazardInfoService.update(confirmHazard);
                                confirmHazardId = confirmHazard.getHazardid();
                                isNewHazard = false;
                                message += "成功修改1条危险源信息；";

                            } else if ((confirmIdentify.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST
                                    || confirmIdentify.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HAZARD) &&
                                    dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()
                            ) {
                                //确认结果为 不存在/第一类 -> 第二类：
                                //（1）上次操作危险源ID的记录：恢复“危险源信息表”中的信息。
                                //根据上次操作的危险源的辨识结果判断当前危险源为第一类危险源还是第二类危险源，再统计一般/重大数量：原数量 - 1
                                if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                    //原记录为第一类危险源
                                    if (lastHazard.isIsmajor()) major1 -= 0x1;
                                    else general1 -= 0x1;
                                } else if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                    //原记录为第二类危险源
                                    if (lastHazard.isIsmajor()) major2 -= 0x1;
                                    else general2 -= 0x1;
                                } else {
                                    //不适用/不存在
                                }

                                //判断上次操作的危险源是否是新增
                                if (confirmIdentify.getConfirmnewhazard()) {
                                    //上次操作的危险源是新增的危险源，删除上次操作的危险源信息
                                    repository.deleteById(lastHazard.getHazardid());
                                } else {
                                    //上次操作的危险源不是新增的危险源
                                    //从“危险源辨识记录表”中查询本次确认的上一条已确认的最新辨识记录，根据此辨识记录恢复上次操作的危险源信息。
                                    LambdaQueryWrapper<EhsHazardIdentify> identifyWrapper = new LambdaQueryWrapper<>();
                                    identifyWrapper.le(EhsHazardIdentify::getTm, confirmIdentify.getTm())
                                            .eq(EhsHazardIdentify::getHasconfirm, true)
                                            .orderByDesc(EhsHazardIdentify::getTm);
                                    EhsHazardIdentify lastIdentify = repository.selectOne(identifyWrapper);
                                    if (Objects.nonNull(lastIdentify)) {
                                        lastHazard.setIdentificationresult(lastIdentify.getConfirmresult().getIndex());
                                        lastHazard.setRecentidentificationtm(DateUtil.getDateTimeString(lastIdentify.getTm()));
                                        hazardInfoService.update(lastHazard);
                                        message += "成功恢复1条危险源信息；";

                                        //根据上次操作的危险源信息恢复后的结果计算单元统计数量+1；
                                        if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                                            //原记录为第一类危险源
                                            if (lastHazard.isIsmajor()) major1 += 0x1;
                                            else general1 += 0x1;
                                        } else if (lastHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                                            //原记录为第二类危险源
                                            if (lastHazard.isIsmajor()) major2 += 0x1;
                                            else general2 += 0x1;
                                        } else {
                                            //不适用/不存在
                                        }
                                    } else {
                                        //没有上一条确认的辨识记录，删除上次操作的危险源信息
                                        repository.deleteById(lastHazard.getHazardid());
                                    }
                                }

                                //(3)修改本次操作危险源ID的记录：修改“危险源信息表“。
                                confirmHazard.setIdentificationresult(dto.getConfirmresult());//危险源辨识结果保存为确认的辨识结果
                                hazardInfoService.update(confirmHazard);
                                confirmHazardId = confirmHazard.getHazardid();
                                isNewHazard = false;
                                message += "成功修改1条危险源信息；";

                                //(4)修改本次操作危险源ID的记录：新增隐患治理记录处理。隐患治理表”中的“发现时间”使用“危险源辨识记录表”中的“辨识时间”。
                                /*是否需要新增隐患治理记录：
                                    a.判断本次确认的辨识记录是否为最新的辨识记录，是则新增；
                                    b.确认结果为第二类危险源（隐患）;
                                    c.对应的隐患ID（不管辨识时间）在“隐患治理表”中不存在任何记录或存在的最新记录状态
                                      为“已整改完成”并且“验收通过”（表示之前相同的隐患已治理）新增隐患治理记录。
                                */
                                //获取指定隐患最新隐患治理记录
                                EhsTroubleCorrectInfoDto troubleDto = troubleCorrectService.getByHazardId(confirmHazard.getHazardid());
                                if ((Objects.isNull(troubleDto) || (troubleDto.isHascorrect() == true && troubleDto.isHascheck() == true))) {
                                    EhsTroubleCorrectInfoDto trouble = new EhsTroubleCorrectInfoDto();
                                    trouble.setHazardid(confirmHazard.getHazardid());
                                    trouble.setOrgcode(confirmIdentify.getOrgcode());
                                    trouble.setTm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                                    trouble.setUnitid(confirmIdentify.getUnitid());
                                    trouble.setUnit(confirmIdentify.getUnitname());
                                    trouble.setFacilityid(confirmIdentify.getFacilityid());
                                    trouble.setFacilityname(confirmIdentify.getFacilityname());
                                    trouble.setCategorycode(confirmIdentify.getCategorycode());
                                    trouble.setCategoryname(confirmIdentify.getCategoryname());
                                    trouble.setProjectcode(confirmIdentify.getProjectcode());
                                    trouble.setProjectname(confirmIdentify.getProjectname());
                                    trouble.setItemcode(confirmIdentify.getItemcode());
                                    trouble.setItemname(confirmIdentify.getItemname());
                                    trouble.setIsmajor(confirmIdentify.getIsmajor());
                                    trouble.setPosition(confirmIdentify.getPosition());
                                    trouble.setCouse(confirmIdentify.getCouse());
                                    trouble.setMaycouseharm(confirmIdentify.getMaycouseharm());
                                    trouble.setTitle(confirmIdentify.getTitle());
                                    trouble.setDescription(confirmIdentify.getDescription());
                                    trouble.setAttachment(confirmIdentify.getAttachment());
                                    trouble.setUnsafefactor(confirmIdentify.getUnsafefactor());
                                    trouble.setIsreport(false);//默认不上报
                                    trouble.setHasdispatch(false);
                                    trouble.setHascorrect(false);
                                    trouble.setHascheck(false);
                                    trouble.setRisklevel(confirmHazard.getRisklevel());
                                    //整改责任部门和整改负责人信息从危险源信息中获取写入；
                                    trouble.setResdeptid(confirmHazard.getResdeptid());
                                    trouble.setResdeptname(confirmHazard.getResdeptname());
                                    trouble.setResuserid(confirmHazard.getResuserid());
                                    trouble.setResusername(confirmHazard.getResusername());
                                    trouble.setResuserphone(confirmHazard.getResuserphone());
                                    troubleCorrectService.add(trouble);
                                    message += "成功新增1条隐患治理记录；";
                                }

                            } else {
                                //不处理
                            }
                        }
                    }
                }

            } else {
                //2.2 辨识记录第一次确认的情况（辨识记录没有确认信息，没有关联的危险源ID）
                if (Objects.nonNull(confirmHazard)) {
                    /*判断本次确认的辨识记录是否为最新的辨识记录，如果辨识时间不为最新仅对危险源辨识记录表中的确认信息进行修改，
                    不对危险源信息表和隐患治理表进行操作。判断条件为：“危险源信息表”中记录的“最近辨识时间”≤“危险源辨识记录表”中的“辨识时间”表示确认的辨识记录为最新辨识记录。
                */
                    if (!DateUtil.parseDate(confirmHazard.getRecentidentificationtm()).after(confirmIdentify.getTm())) {
                        //（1）修改前根据危险源信息的辨识结果计算单元统计数量-1；
                        if (confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
                            //修改前为第一类危险源
                            if (confirmHazard.isIsmajor()) major1 -= 0x1;
                            else general1 -= 0x1;
                        } else if (confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                            //修改前为第二类危险源
                            if (confirmHazard.isIsmajor()) major2 -= 0x1;
                            else general2 -= 0x1;
                        } else {
                            //不存在：不统计
                        }

                        //（2）判断确认的辨识结果：操作隐患治理记录
                        if ((confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST.getIndex()
                                || confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) &&
                                dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()
                        ) {
                            //确认结果为不存在/第一类 -> 第二类：新增隐患治理记录；隐患治理表”中的“发现时间”使用“危险源辨识记录表”中的“辨识时间”。
                            //获取指定隐患最新隐患治理记录
                            EhsTroubleCorrectInfoDto troubleDto = troubleCorrectService.getByHazardId(confirmHazard.getHazardid());
                            if ((Objects.isNull(troubleDto) || (troubleDto.isHascorrect() && troubleDto.isHascheck()))) {
                                EhsTroubleCorrectInfoDto trouble = new EhsTroubleCorrectInfoDto();
                                trouble.setHazardid(confirmHazard.getHazardid());
                                trouble.setOrgcode(confirmIdentify.getOrgcode());
                                trouble.setTm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                                trouble.setUnitid(confirmIdentify.getUnitid());
                                trouble.setUnit(confirmIdentify.getUnitname());
                                trouble.setFacilityid(confirmIdentify.getFacilityid());
                                trouble.setFacilityname(confirmIdentify.getFacilityname());
                                trouble.setCategorycode(confirmIdentify.getCategorycode());
                                trouble.setCategoryname(confirmIdentify.getCategoryname());
                                trouble.setProjectcode(confirmIdentify.getProjectcode());
                                trouble.setProjectname(confirmIdentify.getProjectname());
                                trouble.setItemcode(confirmIdentify.getItemcode());
                                trouble.setItemname(confirmIdentify.getItemname());
                                trouble.setIsmajor(confirmIdentify.getIsmajor());
                                trouble.setPosition(confirmIdentify.getPosition());
                                trouble.setCouse(confirmIdentify.getCouse());
                                trouble.setMaycouseharm(confirmIdentify.getMaycouseharm());
                                trouble.setTitle(confirmIdentify.getTitle());
                                trouble.setDescription(confirmIdentify.getDescription());
                                trouble.setAttachment(confirmIdentify.getAttachment());
                                trouble.setUnsafefactor(confirmIdentify.getUnsafefactor());
                                trouble.setIsreport(false);//默认不上报
                                trouble.setHasdispatch(false);
                                trouble.setHascorrect(false);
                                trouble.setHascheck(false);
                                trouble.setRisklevel(confirmHazard.getRisklevel());
                                //整改责任部门和整改负责人信息从危险源信息中获取写入；
                                trouble.setResdeptid(confirmHazard.getResdeptid());
                                trouble.setResdeptname(confirmHazard.getResdeptname());
                                trouble.setResuserid(confirmHazard.getResuserid());
                                trouble.setResusername(confirmHazard.getResusername());
                                trouble.setResuserphone(confirmHazard.getResuserphone());
                                troubleCorrectService.add(trouble);
                                message += "成功新增1条隐患治理记录；";
                            }
                        } else if (confirmHazard.getIdentificationresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex() &&
                                (dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.NOT_EXIST.getIndex()
                                        || dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex())
                        ) {
                            //确认结果为 第二类 -> 不存在/第一类：删除上次操作新增隐患治理记录处理。
                            EhsTroubleCorrectInfoDto lastTroubleDto = troubleCorrectService.getByHazardIdAnDTm(confirmHazard.getHazardid(), confirmIdentify.getTm());
                            if (Objects.nonNull(lastTroubleDto)) {
                                troubleCorrectService.delete(lastTroubleDto.getCorrectid());
                                message += "成功删除1条隐患治理记录；";
                            }
                        } else {
                            //不处理
                        }

                        //（3）修改危险源信息：辨识结果为确认的辨识结果、辨识时间为辨识记录的辨识时间。
                        confirmHazard.setIdentificationresult(dto.getConfirmresult());
                        confirmHazard.setRecentidentificationtm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                        hazardInfoService.update(confirmHazard);
                        confirmHazardId = confirmHazard.getHazardid();
                        isNewHazard = false;
                        message += "成功修改1条危险源信息；";

                    }
                } else {
                    //（1）如果没有危险源，新增危险源信息，判断确认结果为第二类则新增隐患治理记录
                    confirmHazard = new EhsHazardInfoDto();
                    confirmHazard.setHazardid(IdentifierUtil.randomUUID());
                    confirmHazard.setOrgcode(confirmIdentify.getOrgcode());
                    confirmHazard.setHazardname(confirmIdentify.getItemname());
                    confirmHazard.setUnitid(confirmIdentify.getUnitid());
                    confirmHazard.setUnitname(confirmIdentify.getUnitname());
                    confirmHazard.setFacilityid(confirmIdentify.getFacilityid());
                    confirmHazard.setFacilityname(confirmIdentify.getFacilityname());
                    confirmHazard.setCategorycode(confirmIdentify.getCategorycode());
                    confirmHazard.setCategoryname(confirmIdentify.getCategoryname());
                    confirmHazard.setProjectcode(confirmIdentify.getProjectcode());
                    confirmHazard.setProjectname(confirmIdentify.getProjectname());
                    confirmHazard.setItemcode(confirmIdentify.getItemcode());
                    confirmHazard.setItemname(confirmIdentify.getItemname());
                    confirmHazard.setIsmajor(confirmIdentify.getIsmajor());
                    confirmHazard.setPosition(confirmIdentify.getPosition());
                    confirmHazard.setCouse(confirmIdentify.getCouse());
                    confirmHazard.setMaycouseharm(confirmIdentify.getMaycouseharm());
                    confirmHazard.setTitle(confirmIdentify.getTitle());
                    confirmHazard.setDescription(confirmIdentify.getDescription());
                    confirmHazard.setAttachment(confirmIdentify.getAttachment());
                    confirmHazard.setIdentificationresult(dto.getConfirmresult());//危险源辨识结果保存为确认的辨识结果
                    confirmHazard.setUnsafefactor(confirmIdentify.getUnsafefactor());
                    confirmHazard.setRecentidentificationtm(DateUtil.getDateTimeString(confirmIdentify.getTm()));//最近辨识时间保存为辨识记录的辨识时间
                    confirmHazard.setIsreport(false);//默认不上报
                    //责任部门与责任人信息从单元中获取设置
                    confirmHazard.setResdeptid(unitInfo.getResdeptid());
                    confirmHazard.setResdeptname(unitInfo.getResdeptname());
                    confirmHazard.setResuserid(unitInfo.getResuserid());
                    confirmHazard.setResusername(unitInfo.getResusername());
                    confirmHazard.setResuserphone(unitInfo.getResuserphone());
                    hazardInfoService.add(confirmHazard);
                    confirmHazardId = confirmHazard.getHazardid();
                    isNewHazard = true;
                    message += "成功新增1条危险源信息；";

                    //（2）如果确认的辨识结果为第二类，新增隐患治理记录（根据辨识记录新增）
                    if (isNewHazard && dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
                        EhsTroubleCorrectInfoDto trouble = new EhsTroubleCorrectInfoDto();
                        trouble.setHazardid(confirmHazard.getHazardid());
                        trouble.setOrgcode(confirmIdentify.getOrgcode());
                        trouble.setTm(DateUtil.getDateTimeString(confirmIdentify.getTm()));
                        trouble.setUnitid(confirmIdentify.getUnitid());
                        trouble.setUnit(confirmIdentify.getUnitname());
                        trouble.setFacilityid(confirmIdentify.getFacilityid());
                        trouble.setFacilityname(confirmIdentify.getFacilityname());
                        trouble.setCategorycode(confirmIdentify.getCategorycode());
                        trouble.setCategoryname(confirmIdentify.getCategoryname());
                        trouble.setProjectcode(confirmIdentify.getProjectcode());
                        trouble.setProjectname(confirmIdentify.getProjectname());
                        trouble.setItemcode(confirmIdentify.getItemcode());
                        trouble.setItemname(confirmIdentify.getItemname());
                        trouble.setIsmajor(confirmIdentify.getIsmajor());
                        trouble.setPosition(confirmIdentify.getPosition());
                        trouble.setCouse(confirmIdentify.getCouse());
                        trouble.setMaycouseharm(confirmIdentify.getMaycouseharm());
                        trouble.setTitle(confirmIdentify.getTitle());
                        trouble.setDescription(confirmIdentify.getDescription());
                        trouble.setAttachment(confirmIdentify.getAttachment());
                        trouble.setUnsafefactor(confirmIdentify.getUnsafefactor());
                        trouble.setIsreport(false);//默认不上报
                        trouble.setHasdispatch(false);
                        trouble.setHascorrect(false);
                        trouble.setHascheck(false);
                        //整改责任部门和整改负责人信息从危险源信息中获取写入；
                        trouble.setResdeptid(confirmHazard.getResdeptid());
                        trouble.setResdeptname(confirmHazard.getResdeptname());
                        trouble.setResuserid(confirmHazard.getResuserid());
                        trouble.setResusername(confirmHazard.getResusername());
                        trouble.setResuserphone(confirmHazard.getResuserphone());
                        troubleCorrectService.add(trouble);
                        message += "成功新增1条隐患治理记录；";
                    }
                }
            }

        }

        //6.修改危险源辨识记录表
        confirmIdentify.setHasconfirm(true);
        confirmIdentify.setConfirmresult(confirmIndentificationResult);
        confirmIdentify.setConfirmtm(DateUtil.getNowDate());
        confirmIdentify.setConfirmuserid(userId);
        confirmIdentify.setConfirmusername(username);
        confirmIdentify.setConfirmdescription(dto.getConfirmdescription());
        confirmIdentify.setHazardid(confirmHazardId);
        confirmIdentify.setConfirmnewhazard(isNewHazard);
        repository.updateById(confirmIdentify);
        message += "成功修改1条危险源辨识记录；";

        //根据上次操作的危险源的辨识结果判断当前危险源为第一类危险源还是第二类危险源，再统计一般/重大数量：原数量 - 1
        //判断确认的辨识结果为第一类危险源还是第二类危险源，再统计一般/重大数量：原数量 + 1
        if (dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex()) {
            //第一类危险源
            if (confirmIdentify.getIsmajor()) major1 += 0x1;
            else general1 += 0x1;
        } else if (dto.getConfirmresult() == EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex()) {
            //第二类危险源
            if (confirmIdentify.getIsmajor()) major2 += 0x1;
            else general2 += 0x1;
        }
        //7.修改单元信息
        unitInfo.setIdtm(confirmIdentify.getTm());
        unitInfo.setMajor1(major1);
        unitInfo.setGeneral1(general1);
        unitInfo.setMajor2(major2);
        unitInfo.setGeneral2(general2);
        unitInfoRepository.updateById(unitInfo);
        //更新当前单元的父级信息(直到根节点)
        unitInfoService.modifyParentUnit(unitInfo);
        message += "成功修改1条单元信息；";

        result.setSuccess(true);
        result.setMsg(message);
        return result;
    }

    /**
     * 查询危险源辨识记录确认
     * 用于对危险源辨识记录进行确认操作时的查询条件；可以用于查询辨识记录和查询的上报隐患；
     * 查询结果按照单元名称、类别名称、项目名称、危险源名称升序，再按照辨识时间降序；
     * @param condition 查询条件DTO
     * @return List<HazardIdentifyInfoDto>
     * @author QuCheng Tech
     * @since 2024/11/6
     */
    public List<HazardIdentifyInfoDto> queryConfirm(HazardIdentifyConfirmQueryConditionDto condition) throws QCPromptException {
        //1.查询条件有效性验证
        if (condition == null)
            throw new QCPromptException("查询条件对象不能为空");
        if (StringUtils.isBlank(condition.getOrgcode()))
            throw new QCPromptException("组织机构代码不能为空");
        if (StringUtils.isBlank(condition.getBegintm()))
            throw new QCPromptException("辨识起始时间不能为空");
        if (StringUtils.isBlank(condition.getEndtm()))
            throw new QCPromptException("辨识截止时间不能为空");

        //查询时间处理
        Date beginDate = null;
        Date endDate = null;
        if (StringUtils.isNotBlank(condition.getBegintm())) {
            try {
                beginDate = DateUtil.parseDate(condition.getBegintm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询条件中的开始日期转换错误");
            }
        }
        if (StringUtils.isNotBlank(condition.getEndtm())) {
            try {
                endDate = DateUtil.parseDate(condition.getEndtm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询条件中的截止日期转换错误");
            }
        }

        //2.构建查询条件
        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsHazardIdentify::getOrgcode, condition.getOrgcode());
        //危险源类别：为0表示false(第一类危险源)，为1表示true(第二类危险源)，为空或其他时表示不管该标记状态;
        if (StringUtils.isNotBlank(condition.getIshidden())) {
            if (condition.getIshidden().equals("0") || condition.getIshidden().equals("false")) {
                wrapper.eq(EhsHazardIdentify::getIdentificationresult, EhsHazardIndentificationResultTypeEnum.HAZARD.getIndex());
            } else if (condition.getIshidden().equals("1") || condition.getIshidden().equals("true")) {
                wrapper.eq(EhsHazardIdentify::getIdentificationresult, EhsHazardIndentificationResultTypeEnum.HIDDEN_TROUBLE.getIndex());
            }
        }
        //危险源级别：为0表示false(一般)，为1表示true(重大)，为空或其他时表示不管该标记状态
        if (StringUtils.isNotBlank(condition.getIsmajor())) {
            if (condition.getIsmajor().equals("0") || condition.getIsmajor().equals("false")) {
                wrapper.eq(EhsHazardIdentify::getIsmajor, false);
            } else if (condition.getIsmajor().equals("1") || condition.getIsmajor().equals("true")) {
                wrapper.eq(EhsHazardIdentify::getIsmajor, true);
            }
        }
        //确认状态：0-全部，1-未确认，2-已确认
        if (condition.getConfirmstatus() == 0x1) {
            //未确认
            wrapper.eq(EhsHazardIdentify::getHasconfirm, false);
        } else if (condition.getConfirmstatus() == 0x2) {
            //已确认
            wrapper.eq(EhsHazardIdentify::getHasconfirm, true);
        } else {
            //全部
        }
        //辨识起止时间
        Date finalBeginDate = beginDate;
        Date finalEndDate = endDate;
        wrapper.and(q -> {
            q.ge(EhsHazardIdentify::getTm, finalBeginDate).le(EhsHazardIdentify::getTm, finalEndDate);
        });
        //单元ID
        if (StringUtils.isNotBlank(condition.getUnitid())) {
            wrapper.eq(EhsHazardIdentify::getUnitid, condition.getUnitid());
        }
        //关键字：可以是危险源类别、项目、清单名称、标题
        if (StringUtils.isNotBlank(condition.getKeywords())) {
            wrapper.and(q -> q.like(EhsHazardIdentify::getCategoryname, condition.getKeywords()).or()
                            .like(EhsHazardIdentify::getProjectname, condition.getKeywords()).or()
                            .like(EhsHazardIdentify::getItemname, condition.getKeywords())).or()
                    .like(EhsHazardIdentify::getTitle, condition.getKeywords());
        }
        //排序：按照单元名称、类别名称、项目名称、危险源名称升序，再按照辨识时间降序；
        wrapper.orderByAsc(EhsHazardIdentify::getUnitname, EhsHazardIdentify::getCategoryname,
                EhsHazardIdentify::getProjectname, EhsHazardIdentify::getItemname);
        wrapper.orderByDesc(EhsHazardIdentify::getTm);

        //3.获取指定条件的危险源辨识记录
        List<EhsHazardIdentify> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            List<HazardIdentifyInfoDto> result = new ArrayList<>();
            for (EhsHazardIdentify en : ens) {
                result.add(EhsHazardIdentifyMapper.MAPPER.entityToDto(en));
            }
            return result;
        }
        return null;
    }

    /**
     * 查询我的危险源辨识记录
     * <p>
     * 用于查询指定时间段内单元用户填报的危险源辨识记录；
     * 不管用户的单元权限，只管填报人是当前用户即可；不管辨识记录是否确认；
     * @param condition 查询条件
     * @param userId    用户ID
     * @return List<HazardIdentifyInfoDto>
     * @author QuCheng Tech
     * @since 2024/12/3
     */
    public List<HazardIdentifyInfoDto> queryMy(HazardIdentifyQueryConditionDto condition, int userId) throws QCPromptException {
        //1.查询条件有效性验证
        if (condition == null)
            throw new QCPromptException("查询条件对象不能为空");
        if (StringUtils.isBlank(condition.getOrgcode()))
            throw new QCPromptException("组织机构代码不能为空");
        if (StringUtils.isBlank(condition.getBegintm()))
            throw new QCPromptException("查询起始时间不能为空");
        if (StringUtils.isBlank(condition.getEndtm()))
            throw new QCPromptException("查询截止时间不能为空");
        if (userId < 0x1)
            throw new QCPromptException("用户ID无效");

        //查询时间处理
        Date beginDate = null;
        Date endDate = null;
        if (StringUtils.isNotBlank(condition.getBegintm())) {
            try {
                beginDate = DateUtil.parseDate(condition.getBegintm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询条件中的开始日期转换错误");
            }
        }
        if (StringUtils.isNotBlank(condition.getEndtm())) {
            try {
                endDate = DateUtil.parseDate(condition.getEndtm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询条件中的截止日期转换错误");
            }
        }

        //2.构建查询条件
        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsHazardIdentify::getOrgcode, condition.getOrgcode());
        wrapper.eq(EhsHazardIdentify::getInuserid, userId);//查询记录人为当前用户的辨识记录
        //辨识起止时间
        Date finalBeginDate = beginDate;
        Date finalEndDate = endDate;
        wrapper.and(q -> {
            q.ge(EhsHazardIdentify::getTm, finalBeginDate).le(EhsHazardIdentify::getTm, finalEndDate);
        });
        //单元ID
        if (StringUtils.isNotBlank(condition.getUnitid())) {
            wrapper.eq(EhsHazardIdentify::getUnitid, condition.getUnitid());
        }

        //排序：按照单元名称、类别名称、项目名称、危险源名称升序，再按照辨识时间降序；
        wrapper.orderByAsc(EhsHazardIdentify::getUnitname, EhsHazardIdentify::getCategoryname,
                EhsHazardIdentify::getProjectname, EhsHazardIdentify::getItemname);
        wrapper.orderByDesc(EhsHazardIdentify::getTm);

        //3.获取指定条件的危险源辨识记录
        List<EhsHazardIdentify> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            List<HazardIdentifyInfoDto> result = new ArrayList<>();
            for (EhsHazardIdentify en : ens) {
                result.add(EhsHazardIdentifyMapper.MAPPER.entityToDto(en));
            }
            return result;
        }
        return null;
    }

    /**
     * 获取指定危险源的最新辨识记录
     * @param hazardId 危险源ID
     * @return HazardIdentifyInfoDto
     * @author QuCheng Tech
     * @since 2024/11/8
     */
    public HazardIdentifyInfoDto getLatest(String hazardId) {
        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsHazardIdentify::getHazardid, hazardId)
                .orderByDesc(EhsHazardIdentify::getTm);
        EhsHazardIdentify en = repository.selectOne(wrapper);
        if (Objects.nonNull(en)) {
            return EhsHazardIdentifyMapper.MAPPER.entityToDto(en);
        }
        return null;
    }

    /**
     * 获取指定辨识时间当天的辨识记录
     * 在危险源辨识记录表中存在单元ID、危险源类别、危险源项目、清单代码、辨识时间相同的则为存在；其中辨识时间保留到日，即每天至多有1条记录；
     * @param unitId       单元ID
     * @param categoryCode 危险源类别代码
     * @param projectCode  危险源项目代码
     * @param itemCode     危险源清单代码
     * @param tm           辨识时间
     * @return EhsHazardIdentify
     * @author QuCheng Tech
     * @since 2024/11/12
     */
    private EhsHazardIdentify getidentifyDateIdentify(String unitId, String categoryCode, String projectCode, String itemCode, Date tm) {
        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsHazardIdentify::getUnitid, unitId)
                .eq(EhsHazardIdentify::getCategorycode, categoryCode)
                .eq(EhsHazardIdentify::getProjectcode, projectCode)
                .eq(EhsHazardIdentify::getItemcode, itemCode)
                .likeRight(EhsHazardIdentify::getTm, DateUtil.getDateString(tm));
        EhsHazardIdentify en = repository.selectOne(wrapper);
        if (Objects.nonNull(en)) {
            return en;
        }
        return null;
    }

    /**
     * 查询指定任务项ID的危险源辨识记录
     * @param taskItemId 任务项ID
     * @return List<HazardIdentifyInfoDto>
     * @author QuCheng Tech
     * @since 2024/11/18
     */
    public List<HazardIdentifyInfoDto> getTaskIdentify(String taskItemId) {
        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsHazardIdentify::getTaskitemid, taskItemId)
                .orderByAsc(EhsHazardIdentify::getTm);
        List<EhsHazardIdentify> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            List<HazardIdentifyInfoDto> result = new ArrayList<>();
            for (EhsHazardIdentify en : ens) {
                result.add(EhsHazardIdentifyMapper.MAPPER.entityToDto(en));
            }
            return result;
        }
        return null;
    }

    /**
     * 查询指定组织中指定时间段内的危险源辨识记录集合
     *
     * @param orgCode   组织机构代码
     * @param beginTime 起始时间
     * @param endTime   截止时间
     * @author QuCheng Tech
     */
    public List<EhsHazardIdentify> queryOrgHazardIdentifyEntities(String orgCode, Date beginTime, Date endTime) throws QCPromptException {
        if (StringUtils.isBlank(orgCode))
            throw new QCPromptException("查询危险源辨识记录的组织机构代码不能为空");

        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        //组织机构代码，必须有，判断相等
        wrapper.eq(EhsHazardIdentify::getOrgcode, orgCode);
        //风险等级评价的时间按数据库表中的风险评价时间过滤
        wrapper.ge(EhsHazardIdentify::getTm, beginTime);
        wrapper.le(EhsHazardIdentify::getTm, endTime);

        return repository.selectList(wrapper);
    }

    /**
     * 根据危险源ID和指定的日期获取匹配的1条辨识记录，如果不匹配返回null
     *
     * @param hazardId 危险源ID
     * @param time     辨识日期
     * @return qc.module.ehs.entity.EhsHazardIdentify
     * @author QuCheng Tech
     * @since 2025/1/18
     */
    public EhsHazardIdentify getIdentifyEntityByHazardIdAndTime(String hazardId, Date time) {
        LambdaQueryWrapper<EhsHazardIdentify> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsHazardIdentify::getHazardid, hazardId);
        wrapper.eq(EhsHazardIdentify::getTm, time);

        return repository.selectOne(wrapper);
    }
}
